home *** CD-ROM | disk | FTP | other *** search
/ Die Ultimative Software-P…i Collection 1996 & 1997 / Die Ultimative Software-Pakete CD-ROM fur Atari Collection 1996 & 1997.iso / i / internet / software / tuwtcpsr / mbuf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-06  |  3.2 KB  |  170 lines
  1. #include <stddef.h>
  2. #include <stdlib.h>
  3. #include <tos.h>
  4. #include "mbuf.h"
  5.  
  6. #define Supexec(x) (x())
  7.  
  8. #define SYSBASE ((SYSHDR*)0x4f2L)
  9.  
  10. static BASPAG **oldpd;
  11. long set_pd(void);
  12. long restore_pd(void);
  13.  
  14. char *buf_create(size_t size)
  15. {
  16. register char *buf;
  17.  
  18.     if(size % BUFALIGN)
  19.         size += BUFALIGN - (size % BUFALIGN);
  20.     size += sizeof(mbuf *);
  21.     set_pd();
  22.     buf = Malloc(size);
  23.     restore_pd();
  24.     
  25.     if(!buf) return(NULL);
  26.     
  27.     *(char **)buf = buf+sizeof(char *);    
  28.     (*(mbuf **)buf)->length = size - sizeof(mbuf);
  29.     (*(mbuf **)buf)->blk    = NULL;
  30.     return(buf);
  31. }
  32.  
  33.  
  34. char *buf_alloc(char *buf,size_t size)
  35. {
  36. register mbuf *freeblk;
  37. register mbuf **p_freeblk;
  38. register long align;
  39.  
  40.     
  41.     size += sizeof(size_t);
  42.     align = size % BUFALIGN;
  43.     if(align)
  44.         size += BUFALIGN - align;
  45.     size -= sizeof(size_t);
  46.  
  47.     p_freeblk = (mbuf **)buf;
  48.     freeblk = *p_freeblk;
  49.     while(freeblk && freeblk->length < size)
  50.     {
  51.         p_freeblk = &(freeblk->blk);
  52.         freeblk = freeblk->blk;
  53.     }
  54.     if(!freeblk) return(NULL);
  55.     if(size < freeblk->length)
  56.     {
  57.         *p_freeblk = (mbuf *)((char*)freeblk + size + sizeof(size_t));
  58.         (*p_freeblk)->length = freeblk->length - size - sizeof(size_t);
  59.         (*p_freeblk)->blk = freeblk->blk;
  60.         freeblk->length = size;
  61.     }
  62.     else    /* new block fits exactly */
  63.     {
  64.         *p_freeblk = freeblk->blk;
  65.     }
  66.     return((char *)&freeblk->blk);
  67. }
  68.  
  69.  
  70. int buf_free(char *buf,char *blk)
  71. {
  72. register mbuf *freeblk;
  73. register mbuf **p_freeblk;
  74. register mbuf *nextblk;
  75. mbuf *prevblk;
  76.     
  77.     freeblk = *(mbuf **)buf;
  78.     p_freeblk = NULL;
  79.     nextblk = (mbuf *)(blk + ((size_t *)blk)[-1]);
  80.     prevblk = NULL;
  81.     blk -= sizeof(size_t);
  82.  
  83.     while(freeblk && nextblk > freeblk)
  84.     {
  85.         if(freeblk == (mbuf *)blk) return(0);
  86.         if(!prevblk)
  87.         {
  88.             p_freeblk = (mbuf **)buf;
  89.         }
  90.         else
  91.         {
  92.             p_freeblk = &((*p_freeblk)->blk);
  93.         }
  94.         prevblk = freeblk;
  95.         freeblk = freeblk->blk;
  96.     }
  97.     if(nextblk == freeblk)        /* connect trailing free block */
  98.     {
  99.         ((mbuf *)blk)->length += freeblk->length + sizeof(size_t);
  100.         ((mbuf *)blk)->blk = freeblk->blk;
  101.     }
  102.     else    /* create a hole */
  103.     {
  104.         /* keep length of block */
  105.         ((mbuf *)blk)->blk = freeblk;
  106.     }
  107.     if(prevblk && (char *)prevblk+prevblk->length+sizeof(size_t) == blk)
  108.     {            /* connect leading free block */
  109.         prevblk->blk = ((mbuf *)blk)->blk;
  110.         prevblk->length += ((mbuf *)blk)->length + sizeof(size_t);
  111.     }
  112.     else
  113.     {
  114.         if(!p_freeblk)
  115.         {
  116.             *((mbuf **)buf) = (mbuf *)blk;
  117.         }
  118.         else
  119.         {
  120.             prevblk->blk = (mbuf *)blk;
  121.         }
  122.     }
  123.     return(1);
  124. }
  125.  
  126.  
  127. long set_pd(void)
  128. {
  129.   oldpd = SYSBASE->_run;
  130.   SYSBASE->_run = &_BasPag;
  131.   return 0;
  132. }
  133.  
  134. long restore_pd(void)
  135. {
  136.   SYSBASE->_run = oldpd;
  137.   return 0;
  138. }
  139.  
  140.  
  141.  
  142. char *getmem(register long size)
  143. {
  144.   char *got;
  145.  
  146.   /* this relies on malloc taking size_t, and size_t being long, */
  147.   /* or else not compiling with -mshort */
  148.   Supexec(set_pd);
  149.   got = (char *) malloc(size);
  150.   Supexec(restore_pd);
  151.   return got;
  152. }
  153.  
  154.  
  155. char *resizemem(register void *ptr,register long size)
  156. {
  157.   char *got;
  158.  
  159.   got = (char *) realloc(ptr,size);
  160.   return got;
  161. }
  162.  
  163.  
  164. void freemem( void *ptr)
  165. {
  166.     Supexec(set_pd);        /* set own pid */
  167.     free(ptr);
  168.     Supexec(restore_pd);    /* restore previous pid */
  169. }
  170.